import javax.swing.plaf.TableHeaderUI;
import java.lang.management.MemoryType;
import java.util.Timer;
import java.util.concurrent.*;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User:岁亮亮  创建线程 的几种方式
 * Date:2024-10-14
 * TIME:12:31
 */
class MyCallable implements Callable<String>{
    @Override
    public String call() throws Exception {
        System.out.println("这是一个有返回值的线程");
        return "返回值线程";
    }
}
//第一种 继承 Thread
class Myhead extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("这个线程叫 " + Thread.currentThread().getName());

       }
    }
}
//实现Runnable 接口
//Runnable接口提供了 线程要执行的任务是什么 被重写的方法内部就是一个线程要执行的任务
//Runnable 将线程 与线程的任务进行了解耦合的作用 并提供多继承的作用
class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {

            System.out.println("zhesi");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class Thread1 {
    /***
     * isAlive 判断线程是否执行完毕即 在内核中该线程的tcb 是否被释放
     * 该线程实例 与线程的生命周期是不同的 线程执行完之后 它的tcb 就被释放了
     * 而 线程实例本身就是一个变量  它的生命周期不取决于他自己
     *
     * @param
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("线程的是否存在 " + Thread.currentThread().isAlive());
            }
        });
        t.start();
       Thread.sleep(5000);
        System.out.println("线程是否存在 "+ t.isAlive());//线程执行完后 线程就不存在了而t变量还是存活状态
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程在工作");
        }

    }
    public static void main4(String[] args) throws ExecutionException, InterruptedException {
        //利用Callable接口创建一个有返回值的 call 方法 的任务  可以利用适配器转化为线程的入口方法run
        //利用futuretask类来 提交任务到线程池中让某一个线程来完成任务 也可以作为一个Runnable的实例去让一个线程去执行
        FutureTask<String> f = new FutureTask<>(new MyCallable());
        new Thread(f).start();
        String str = f.get();
        System.out.println(str);

        //
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        Callable<Integer>[] callables = new Callable[5];
        for (int i = 0; i < callables.length; i++) {
             int index = 1;
            callables[i] = new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {

                    TimeUnit.SECONDS.sleep(index + 1);
                    return (index ) * 100;
                }
            };
        }
        FutureTask<Integer>[] futureTasks = new FutureTask[callables.length];
        for (int i = 0; i < callables.length; i++) {
            futureTasks[i] = new FutureTask<>(callables[i]);
            executorService.submit(futureTasks[i]);
        }
        for (int i = 0; i < callables.length; i++) {
            Integer tesult = futureTasks[i].get();
            System.out.println(tesult);

        }
        executorService.shutdown();


    }
    public static void main3(String[] args) throws InterruptedException {
        //第三种 创建一个匿名内部类 但只能利用一次不能重复使用
        int index = 0;
        Thread t2 = new Thread(){
            @Override
            public void run() {

                System.out.println(index);
            }
        };
        //用lambda 表达式  也可以代表创建的一个匿名内部类
        Thread t = new Thread(() ->{

           while(true) {
                try {
                    //Thread.sleep()会抛出异常InterruptedException 中断异常
                    //就是说在休眠的的时候提前被唤醒而抛出的异常再对异常进行 进行执行定义的代码逻辑
                    //在main 方法会抛出异常
                    //在run方法线程的入口方法调用sleep 要进行捕捉异常而不是抛出异常以为 Runnable的run方法本身没有抛出异常
                    //被重写的方法也不能抛出异常
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
              System.out.println(Thread.currentThread().getThreadGroup().getMaxPriority());//10

                System.out.println("这是一个辅助线程距离看这些涵盖了整个建筑");


            }



        });
        t.start();

      while(true){

          System.out.println("这是一个主线程");
          System.out.println(t.getState());

      }

        /*t.start();//创建新线程 新线程去执行run方法 main主线程无需去管继续执行往下自己的业务逻辑
        t.run();//调用t线程中的run方法是main主线程的任务 而不是创建一个新线程为main线程分担任务*/

       /* while(true){

            System.out.println("这是一个主线程");
        }*/
    }
    public static void main2(String[] args) throws InterruptedException {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        t1.start();
        Thread.sleep(1000);
        System.out.println("zhuxiancheng");
    }

    public static void main1(String[] args) throws InterruptedException {
        Myhead t1 = new Myhead();
        Myhead t2 = new Myhead();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("这是主线程");


    }
}
